Webserver Architecture — The Quiet Engine

The webserver in Pytigon isn't a single thing — it's a layered abstraction that adapts to its environment. Development on localhost? Production behind Nginx? Running inside a Docker container? Pytigon's server layer handles all of these without changing a single line of your application code.

The Server Stack

[graphviz]

Multi-Protocol Support

Pytigon's server speaks multiple protocols simultaneously, each optimized for a different communication pattern:

HTTP/REST — The Backbone

Every Django view in Pytigon doubles as a REST endpoint. The generic table views automatically expose list, add, edit, and delete operations over HTTP. Add ?format=json to any list URL and you get machine-readable data instead of HTML tables.

Key endpoints follow this URL structure:

[app_name]/table/[TableName]/                              → HTML table (list view)
[app_name]/table/[TableName]/list/                          → AJAX list data
[app_name]/table/[TableName]/[id]/edit/                     → Edit form
[app_name]/table/[TableName]/add/                           → Add form
[app_name]/table/[TableName]/action/[action_name]/          → Custom actions
[app_name]/table/[TableName]/[id]/[target]/[view_type]/     → Complex view

WebSockets — The Live Wire

Django Channels provides WebSocket support for real-time bidirectional communication. Pytigon extends this with:

  • Channel consumers — Define per-application consumers in consumers.py
  • Room-based messaging — Group connections by logical rooms
  • Task integration — Background tasks can push updates to WebSocket clients
  • Automatic reconnection — Client-side reconnection logic with exponential backoff

GraphQL — The Precise Query

For applications that need fine-grained data fetching, Pytigon integrates GraphQL through Django's ObjectType system. Define your schema, and clients can request exactly the fields they need — no more, no less.

XML-RPC — The Legacy Bridge

For integration with legacy systems, Pytigon exposes XML-RPC endpoints. Background tasks can be registered as RPC functions, callable from any XML-RPC client.

The ASGI Bridge

Pytigon includes a custom ASGI bridge (schhttptools.asgi_bridge) that enables communication between the desktop client and the embedded server. This bridge:

  1. Starts a local ASGI server when the desktop app launches
  2. Handles authentication automatically (the desktop client is trusted)
  3. Routes WebSocket connections for real-time features
  4. Manages the server lifecycle — start on app launch, stop on app close

Development vs Production

Development Mode

python manage.py runserver

The Django development server. Hot-reloading. Debug toolbar. All the nice things developers love. Plus Daphne for WebSocket support.

Production Mode

For production, Pytigon recommends:

Nginx → Gunicorn (WSGI) + Daphne (ASGI) → Django

Nginx handles: - Static file serving - SSL termination - Load balancing - Request buffering

Gunicorn handles WSGI (standard HTTP), and Daphne handles ASGI (WebSockets). Both point to the same Django application.

Docker Deployment

The AppImage and Docker container modes bundle everything — server, client components, and database connectors — into a single portable unit. Perfect for development environments and small-scale deployments where the overhead of a full production setup isn't justified.

Server-Side Rendering & Document Generation

The server doesn't just serve web pages. It generates:

  • PDF documents — Using the schhtml rendering engine, converting .ihtml templates to pixel-perfect PDFs
  • ODF documents — Open Document Format for office suite compatibility
  • XLSX spreadsheets — Excel-compatible spreadsheets with formulas and formatting
  • CSV exports — For data interchange
  • Email content — HTML emails rendered from the same template system

Each output format uses a different device context (basedc, pdfdc, xlsxdc, etc.) but the same template and rendering pipeline.

Authentication & Authorization

Pytigon layers on top of Django's auth system:

  • django-allauth integration — Social login via Google, Facebook, GitHub, etc.
  • OAuth2 provider — Pytigon can act as an OAuth2 authorization server
  • Permission-based menu filtering — Menu items automatically hide/show based on user permissions
  • Row-level filtering — Models can define filter_by_permissions() to restrict which rows a user can see
  • JWT support — For API authentication

Performance Considerations

  • Database connection pooling — Django's built-in persistent connections
  • Template caching — Compiled .ihtml → .html templates are cached
  • Static file versioning — Cache-busting via content hashing
  • Lazy loading — Tables load data on demand via AJAX
  • QuerySet optimization — Generic views automatically apply select_related and prefetch_related where possible
?: Webserver ?: Webserver